home *** CD-ROM | disk | FTP | other *** search
/ EuroCD 3 / EuroCD 3.iso / Programming / RTGMaster / demos / moon / MOON.C < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-24  |  21.3 KB  |  826 lines
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <ctype.h>
  4. #include <time.h>
  5. #include <dos.h>
  6. #include <string.h>
  7. #include "SysInclude.h"
  8. #include <rtgmaster/rtgmaster.h>
  9. #include <rtgmaster/rtgsublibs.h>
  10. #include <clib/rtgmaster_protos.h>
  11. #include <pragmas/rtgmaster_pragmas.h>
  12. #include <rtgmaster/rtgc2p.h>
  13. #include "rtggadgets.h"
  14. #include <libraries/asl.h>
  15. #include <proto/console.h>
  16. #include <proto/utility.h>
  17.  
  18.  
  19. #define SMRTITLE ("Simplest ScreenMode Requester")
  20.  
  21. struct RtgScreen *RtgScreen;
  22. struct ScreenReq *sr;
  23. struct RTGMasterBase *RTGMasterBase;
  24.  
  25. struct Library *IntuitionBase;
  26. struct Library *GfxBase;
  27. struct Library *AslBase;
  28. UBYTE *sadr;
  29. framemode=2;
  30.  
  31. #include "random.h"
  32. #include "boolean.h"
  33. #include "fixed.h"
  34. #include "world.h"
  35.  
  36. long clip_mask_x  = map_size_x - 1;
  37. long clip_mask_y  = map_size_y - 1;
  38.  
  39. long scale_height = 128;
  40.  
  41. long world_size_x = map_size_x * scale_area;
  42. long world_size_y = map_size_y * scale_area;
  43.  
  44. long max_alt = 255;
  45. long min_alt = 0;
  46. #define view_size     80
  47. long view_start = view_size / 2;
  48.  
  49. long win_cen_x=160;
  50. long win_cen_y=100;
  51.  
  52. long black      =0;
  53. long cursor_color=255;
  54.  
  55. typedef struct{
  56.    int x;
  57.    int y;
  58.    int z;
  59.  
  60.    angle_t angle;
  61.    fixed   sine;
  62.    fixed   cosine;
  63. }viewer_t;
  64.  
  65. static viewer_t    viewer;
  66.  
  67. typedef struct{
  68.   int x1;      /* Left   */
  69.   int y1;      /* Top    */
  70.   int x2;      /* Right  */
  71.   int y2;      /* Bottom */
  72.   int win_cen_x,win_cen_y;
  73.   int dither_mode;
  74. } win_t;
  75.  
  76. static win_t win=
  77. {
  78.    0, 0, 319, 199,0,0,5
  79. };
  80.  
  81.  
  82. typedef struct{
  83.    int             y;
  84.    unsigned char   color;
  85. } col_t   ;
  86.  
  87. static col_t       col     [ 321 ];
  88. static col_t       old_col [ 321 ];
  89. typedef struct{
  90.   unsigned long r,g,b;
  91. }color_t;
  92. color_t colors[256];
  93. ULONG cmap[800];
  94. int Planar=FALSE;
  95. ULONG c2psignal;
  96.  
  97. extern int __asm mul_and_div(register __d0 int a,register __d1 int b,register __d2 int c);
  98.  
  99. extern int __asm dot_product(register __d0 int u1,register __d1 int v1, register __d2 int u2, register __d3 int v2);
  100.  
  101. extern void __asm rotate(register __a0 void *x,register __a1 void *y,register __d0 int sine,register __d1 int cosine);
  102.  
  103. extern void __asm copy(register __a0 void *src,register __a1 void *dest,register __d0 ULONG method);
  104.  
  105. static unsigned char tmp_scr[200][320];
  106.  
  107. void ToScreen(struct RtgScreen *RtgScreen)
  108. {
  109.  
  110.   /*if(Planar==TRUE){
  111.     CallRtgC2P(RtgScreen,sadr,tmp_scr,c2psignal,0,0,320,200,c2p_1x1);
  112.     Wait(1<<c2psignal);
  113.   }else CopyRtgPixelArray(RtgScreen,sadr,tmp_scr,win.x1,0,win.x2-win.x1+1,200,0,0);
  114.   */
  115.   copy(tmp_scr,sadr,0);
  116. }
  117.  
  118. void view_overhead_map (struct RtgScreen *RtgScreen)
  119. {
  120.   int start_x  =  (int) (viewer.x / scale_area) - win_cen_x;
  121.   int start_y  =  (int) (viewer.y / scale_area) - win_cen_y;
  122.  
  123.   int x,y,map_y,map_x;
  124.  
  125.   start_x &= clip_mask_x;
  126.   start_y &= clip_mask_y;
  127.  
  128.   map_x = start_x;
  129.   for(y=0;y<200;++y){
  130.     map_y=(start_y+y)&clip_mask_y;
  131.     for(x=0;x<win.x2-win.x1; ++ x ){
  132.       map_x=(start_x+x+win.x1)&clip_mask_x;
  133.       tmp_scr[y][x]=(UBYTE)color_map[map_x][map_y];
  134.     }
  135.   }
  136.  
  137.   ToScreen(RtgScreen);
  138.   {
  139.     int x1 = dot_product (  viewer.sine,   viewer.cosine,  20, 0 ) + 160;
  140.     int y1 = dot_product ( -viewer.cosine, viewer.sine,    20, 0 ) + 100;
  141.     int x2 = dot_product (  viewer.sine,   viewer.cosine,  30, 0 ) + 160;
  142.     int y2 = dot_product ( -viewer.cosine, viewer.sine,    30, 0 ) + 100;
  143.     DrawRtgLine(RtgScreen, sadr,255,x1,y1,x2,y2);
  144.     DrawRtgLine(RtgScreen, sadr,255,159, 99,162, 99);
  145.     DrawRtgLine(RtgScreen, sadr,255,162, 99,162,102);
  146.     DrawRtgLine(RtgScreen, sadr,255,162,102,159,102);
  147.     DrawRtgLine(RtgScreen, sadr,255,159,102,159, 99);
  148.   }
  149. }
  150.  
  151. unsigned char calc_color(int map_x, int map_y)
  152. {
  153.   return(color_map[map_x][map_y]);
  154. }
  155.  
  156. static void draw_row(struct RtgScreen *RtgScreen)
  157. {
  158.  
  159.    int   x,y;
  160.  
  161.    for(x=win.x1;x<win.x2;++x){
  162.      if(col[x].y<0 )col[x].y=0; else if(col[x].y>199)col[x].y=199;
  163.    }
  164.    if(win.dither_mode==0){
  165.      for(x=win.x1;x<win.x2;++x){
  166.        tmp_scr[col[x].y][x-win.x1]=(unsigned char)col[x].color;
  167.        old_col[x].y    =col[x].y;
  168.        old_col[x].color=col[x].color;
  169.      }
  170.    }else if(win.dither_mode==1){
  171.      for(x=win.x1;x<win.x2;++x){
  172.        if(old_col[x].y<=col[x].y){
  173.          for(y=old_col[x].y;y<col[x].y;y++){
  174.            tmp_scr[y][x-win.x1]=(unsigned char)old_col[x].color;
  175.          }
  176.        }
  177.        old_col[x].y    =col[x].y;
  178.        old_col[x].color=col[x].color;
  179.      }
  180.    }else if(win.dither_mode==2){
  181.      for(x=win.x1;x<win.x2;++x){
  182.        int color=old_col[x].color;
  183.        int dcol=col[x].color-old_col[x].color;
  184.        int dy=col[x].y-old_col[x].y;
  185.        int scr_x=x-win.x1;
  186.        for(y=old_col[x].y;y<col[x].y;y++){
  187.          tmp_scr[y][scr_x]=(unsigned char)color;
  188.          color=old_col[x].color+(dcol)*((y-old_col[x].y+1)/dy);
  189.        }
  190.        old_col[x].y    =col[x].y;
  191.        old_col[x].color=col[x].color;
  192.      }
  193.    }else{
  194.      for(x=win.x1;x<win.x2;++x){
  195.       int dif=col[x].y-old_col[x].y;
  196.        if(dif>0){
  197.          int color=old_col[x].color;
  198.          int den=col[x].y-old_col[x].y;
  199.          int num=col[x].color-color;
  200.          int color_inc;
  201.          int i=0,err=0;
  202.          int scr_x=x-win.x1;
  203.          if(num<0){color_inc=-1;num=-num;}
  204.          else color_inc=1;
  205.          while(i<dif){
  206.            tmp_scr[old_col[x].y+i][scr_x]=(unsigned char)color;
  207.            i++;
  208.            err+=num;
  209.            while(err>=den){
  210.              err  -=den;
  211.              color+=color_inc;
  212.            }
  213.          }
  214.        }
  215.        old_col[x].y    =col[x].y;
  216.        old_col[x].color=col[x].color;
  217.      }
  218.    }
  219.  
  220.  
  221. }
  222.  
  223. static void view_3d(struct RtgScreen *RtgScreen)
  224. {
  225.    const sz = 240; 
  226.    int x;
  227.  
  228.  
  229.    int viewer_map_x=viewer.x/scale_area;
  230.    int viewer_map_y=viewer.y/scale_area;
  231.  
  232.    int map_start_x,    map_start_y;
  233.    int map_start_x_inc,map_start_y_inc;
  234.    int map_x_inc,      map_y_inc;
  235.  
  236.    int start_x,        start_y;
  237. #ifdef ALT19_03_96
  238.    if(viewer.angle < 450 || viewer.angle >= 3150 ){
  239.       map_start_x     = (viewer_map_x-view_start) & clip_mask_x;
  240.       map_start_y     = (viewer_map_y-view_start) & clip_mask_y;
  241.       map_start_x_inc = 0;
  242.       map_start_y_inc = 1;
  243.       map_x_inc       = 1;
  244.       map_y_inc       = 0;
  245.  
  246.       start_x         = -view_start * scale_area;
  247.       start_y         =  view_start * scale_area;
  248.    }else if( viewer.angle<1350 ){
  249.       map_start_x     = (viewer_map_x+view_start) & clip_mask_x;
  250.       map_start_y     = (viewer_map_y-view_start) & clip_mask_y;
  251.       map_start_x_inc = -1;
  252.       map_start_y_inc = 0;
  253.       map_x_inc       = 0;
  254.       map_y_inc       = 1;
  255.  
  256.       start_x         = view_start * scale_area;
  257.       start_y         = view_start * scale_area;
  258.    }else if( viewer.angle<2250 ){
  259.       map_start_x     = (viewer_map_x+view_start) & clip_mask_x;
  260.       map_start_y     = (viewer_map_y+view_start) & clip_mask_y;
  261.       map_start_x_inc = 0;
  262.       map_start_y_inc = -1;
  263.       map_x_inc       = -1;
  264.       map_y_inc       = 0;
  265.  
  266.       start_x         =  view_start * scale_area;
  267.       start_y         = -view_start * scale_area;
  268.    }else{
  269.       map_start_x     = (viewer_map_x-view_start) & clip_mask_x;
  270.       map_start_y     = (viewer_map_y+view_start) & clip_mask_y;
  271.       map_start_x_inc = 1;
  272.       map_start_y_inc = 0;
  273.       map_x_inc       = 0;
  274.       map_y_inc       = -1;
  275.  
  276.       start_x         = -view_start * scale_area;
  277.       start_y         = -view_start * scale_area;
  278.    }
  279. #endif
  280.    if(viewer.angle < 450 || viewer.angle >= 3150 ){
  281.       map_start_x     = (viewer_map_x-view_start) & clip_mask_x;
  282.       map_start_y     = (viewer_map_y-view_start) & clip_mask_y;
  283.       map_start_x_inc = 0;
  284.       map_start_y_inc = 1;
  285.       map_x_inc       = 1;
  286.       map_y_inc       = 0;
  287.  
  288.       start_x         = -view_start * scale_area;
  289.       start_y         =  view_start * scale_area;
  290.    }else if( viewer.angle<1350 ){
  291.       map_start_x     = (viewer_map_x+view_start) & clip_mask_x;
  292.       map_start_y     = (viewer_map_y-view_start) & clip_mask_y;
  293.       map_start_x_inc = -1;
  294.       map_start_y_inc = 0;
  295.       map_x_inc       = 0;
  296.       map_y_inc       = 1;
  297.  
  298.       start_x         = view_start * scale_area;
  299.       start_y         = view_start * scale_area;
  300.    }else if( viewer.angle<2250 ){
  301.       map_start_x     = (viewer_map_x+view_start) & clip_mask_x;
  302.       map_start_y     = (viewer_map_y+view_start) & clip_mask_y;
  303.       map_start_x_inc = 0;
  304.       map_start_y_inc = -1;
  305.       map_x_inc       = -1;
  306.       map_y_inc       = 0;
  307.  
  308.       start_x         =  view_start * scale_area;
  309.       start_y         = -view_start * scale_area;
  310.    }else{
  311.       map_start_x     = (viewer_map_x-view_start) & clip_mask_x;
  312.       map_start_y     = (viewer_map_y+view_start) & clip_mask_y;
  313.       map_start_x_inc = 1;
  314.       map_start_y_inc = 0;
  315.       map_x_inc       = 0;
  316.       map_y_inc       = -1;
  317.  
  318.       start_x         = -view_start * scale_area;
  319.       start_y         = -view_start * scale_area;
  320.    }
  321.  
  322.  
  323.    start_x -= (viewer.x % scale_area);
  324.    start_y += (viewer.y % scale_area);
  325.  
  326.    {
  327.      int world_x_inc =  map_x_inc * scale_area;
  328.      int world_y_inc = -map_y_inc * scale_area;
  329.      int start_x_inc,start_y_inc;
  330.      int nr_rows;
  331.  
  332.      rotate(&start_x,    &start_y,    viewer.sine,viewer.cosine);
  333.      rotate(&world_x_inc,&world_y_inc,viewer.sine,viewer.cosine);
  334.  
  335.      start_x_inc= world_y_inc;
  336.      start_y_inc=-world_x_inc;
  337.  
  338.  
  339.      memset(tmp_scr,0,sizeof(tmp_scr));
  340.  
  341.  
  342.      for ( x = 0; x <win.x2-win.x1; ++ x ){
  343.         col[x].y=old_col[x].y     = win.y2;
  344.         col[x].color=old_col[x].color = 0;
  345.      }
  346.  
  347.      for(nr_rows=view_size/2;nr_rows>0;--nr_rows ){
  348.         int map_x=map_start_x;
  349.         int map_y=map_start_y;
  350.  
  351.         int world_x=start_x;
  352.         int world_y=start_y;
  353.         int world_z=viewer.z-alt_map[map_x][map_y]*scale_height;
  354.  
  355.         int last_sx=win.x2;
  356.         int last_sy=win.y1;
  357.         int last_color=0;
  358.  
  359.         int nr_cols=view_size;
  360.  
  361.         while(nr_cols>0){
  362.  
  363.            if(world_y>0){
  364.               int sx=mul_and_div(world_x,sz,world_y)+win_cen_x;
  365.               int sy=mul_and_div(world_z,sz,world_y)+win_cen_y;
  366.               int color=calc_color(map_x,map_y);
  367.  
  368.               if(sx>win.x1){
  369.                  int den=sx-last_sx;
  370.  
  371.                  int num=color-last_color;
  372.                  int color_inc;
  373.                  int err,num2,last_sy_inc,err2;
  374.  
  375.                  if(num<0){color_inc=-1;num=-num;}else color_inc=1;
  376.  
  377.                  err=0;
  378.                  num2=sy-last_sy;
  379.                  if(num2<0){last_sy_inc=-1;num2=-num2;}else last_sy_inc=1;
  380.  
  381.                  err2=0;
  382.  
  383.                  if(last_sx<win.x1 ){
  384.                    int delta=win.x1-last_sx;
  385.  
  386.                    err=num*delta%den;
  387.                    last_color+=color_inc*num*delta/den;
  388.  
  389.                    err2=num2*delta%den;
  390.                    last_sy+=last_sy_inc*num2*delta/den;
  391.  
  392.                    last_sx=win.x1;
  393.                  }
  394.  
  395.                  if(sx>win.x2)sx=win.x2;
  396.  
  397.                  for(x=last_sx;x<sx;++x){
  398.  
  399.                     col[x].y    =last_sy;
  400.                     col[x].color=(unsigned char) last_color;
  401.  
  402.                     err+=num;
  403.                     while(err >=den){
  404.                        err-=den;
  405.                        last_color+=color_inc;
  406.                     }
  407.  
  408.                     err2+=num2;
  409.                     while(err2>=den){
  410.                       err2-=den;
  411.                       last_sy+=last_sy_inc;
  412.                     }
  413.                  }
  414.  
  415.                  if(sx==win.x2)break;
  416.               }
  417.  
  418.               last_sx=sx;
  419.               last_sy=sy;
  420.               last_color=color;
  421.            }
  422.  
  423.  
  424.  
  425.            map_x=(map_x+map_x_inc)&clip_mask_x;
  426.            map_y=(map_y+map_y_inc)&clip_mask_y;
  427.  
  428.            world_x+=world_x_inc;
  429.            world_y+=world_y_inc;
  430.            world_z =viewer.z - alt_map [map_x][map_y] * scale_height;
  431.  
  432.            --nr_cols;
  433.         }
  434.  
  435.  
  436.  
  437.         draw_row(RtgScreen);
  438.  
  439.  
  440.  
  441.         start_x+=start_x_inc;
  442.         start_y+=start_y_inc;
  443.  
  444.         map_start_x=(map_start_x+map_start_x_inc)&clip_mask_x;
  445.         map_start_y=(map_start_y+map_start_y_inc)&clip_mask_y;
  446.      }
  447.    }
  448.  
  449.  
  450.  
  451.    for ( x = win.x1; x < win.x2; ++ x ){
  452.       col [x].y     = win.y2;
  453.       col [x].color = calc_color (viewer_map_x, viewer_map_y);
  454.    }
  455.  
  456.    draw_row(RtgScreen);
  457.    ToScreen(RtgScreen);
  458.  
  459. }
  460.  
  461.  
  462.  
  463.  
  464. void set_palette(struct RtgScreen *RtgScreen)
  465. {
  466.  
  467.    int i;
  468.  
  469.    memset(colors,0,sizeof(colors));
  470.  
  471.    for(i=0;i<64;++i){
  472.      colors[i+1].r=(unsigned char)i;
  473.      colors[i+1].g=(unsigned char)(i*i/63);
  474.      colors[i+1].b=(unsigned char)(i*i/63);
  475.    }
  476.  
  477.    colors[255].r =16;
  478.    colors[255].g =63;
  479.    colors[255].b =0;
  480.    {
  481.     UBYTE rr, rg, rb;
  482.  
  483.     int x,i;
  484.     cmap[0] = 256 * 65536;
  485.     rr = 0;
  486.     rg = 0;
  487.     rb = 0;
  488.     x = 1;
  489.     for (i = 0; i < 64; i++) {
  490.         cmap[x++] = rr * 0x1111111;
  491.         cmap[x++] = rg * 0x1111111;
  492.         cmap[x++] = rb * 0x1111111;
  493.         rr += 3;
  494.     }
  495.     for (i = 0; i < 127; i++) {
  496.         cmap[x++] = rr * 0x1111111;
  497.         cmap[x++] = rg * 0x1111111;
  498.         cmap[x++] = rb * 0x1111111;
  499.         rg += 3;
  500.     }
  501.     for (i = 0; i < 60; i++) {
  502.         cmap[x++] = rr * 0x1111111;
  503.         cmap[x++] = rg * 0x1111111;
  504.         cmap[x++] = rb * 0x1111111;
  505.         rb += 3;
  506.     }
  507.     for (i = 0; i < 4; i++) {
  508.         cmap[x++]=0xFFFFFFFF;
  509.         cmap[x++]=0xFFFFFFFF;
  510.         cmap[x++]=0xFFFFFFFF;
  511.     }
  512.     cmap[x++]=0;
  513.  
  514.     LockRtgScreen(RtgScreen);
  515.     LoadRGBRtg(RtgScreen, (APTR)cmap);
  516.     UnlockRtgScreen(RtgScreen);
  517.   }
  518. }
  519.  
  520. int Clear_Screen(struct RtgScreen *RtgScreen)
  521. {
  522.   memset(tmp_scr,0,sizeof(tmp_scr));
  523.   ToScreen(RtgScreen);
  524.   return(0);
  525. }
  526.  
  527. typedef enum{cockpit_view,map_view}view_t;
  528.  
  529. void interact(struct RtgScreen *RtgScreen)
  530. {
  531.    BYTE buffer[10];
  532.    float frames=0;
  533.    const           clearance     = 8           * scale_height;
  534.    const           max_altitude  = (max_alt+4) * scale_height;
  535.    int vel = 0;
  536.    int vz  = 0;
  537.    int va  = 0;
  538.    boolean done         =FALSE;
  539.    view_t  view         =cockpit_view;
  540.    long t1,t2,anz_frames=0;
  541.    time(&t1);
  542.  
  543.  
  544.    viewer.x     = 4 * scale_area;
  545.    viewer.y     = 4 * scale_area;
  546.    viewer.z     = color_map [4][4] * scale_height + clearance;
  547.    viewer.angle = 1800;
  548.  
  549.  
  550.    while ( ! done ){
  551.  
  552.       int vx,vy,map_x,map_y;
  553.  
  554.  
  555.       viewer.angle += va;
  556.  
  557.       while ( viewer.angle <  0    )  viewer.angle += 3600;
  558.       while ( viewer.angle >= 3600 )  viewer.angle -= 3600;
  559.  
  560.       FIX_cos_sin ( viewer.angle, & viewer.cosine, & viewer.sine );
  561.  
  562.  
  563.       vx = mul_and_div ( vel, -viewer.sine,  65536 );
  564.       vy = mul_and_div ( vel, viewer.cosine, 65536 );
  565.  
  566.       map_x = (int) (viewer.x / scale_area);
  567.       map_y = (int) (viewer.y / scale_area);
  568.  
  569.       viewer.x += vx;
  570.       viewer.y += vy;
  571.  
  572.       while(viewer.x< 0           ) viewer.x+=world_size_x;
  573.       while(viewer.x>=world_size_x) viewer.x-=world_size_x;
  574.  
  575.       while(viewer.y< 0           ) viewer.y+=world_size_y;
  576.       while(viewer.y>=world_size_y) viewer.y-=world_size_y;
  577.  
  578.  
  579.       viewer.z += vz;
  580.  
  581.       if(viewer.z<alt_map [map_x][map_y] * scale_height + clearance ){
  582.         viewer.z=alt_map [map_x][map_y] * scale_height + clearance;
  583.         vz      =0;
  584.       }else if(viewer.z > max_altitude ){
  585.         viewer.z=max_altitude;
  586.         vz      =0;
  587.       }
  588.  
  589.  
  590.  
  591.       if(view==cockpit_view)view_3d(RtgScreen);
  592.       else view_overhead_map(RtgScreen);
  593.       if (framemode)
  594.       {
  595.       ++anz_frames;
  596.       if(anz_frames>=10){
  597.         char gww[20];
  598.         float diff;
  599.         time(&t2);
  600.         diff=(t2-t1);
  601.         if(diff>0){
  602.           float g=(anz_frames)/diff;
  603.           diff=g;
  604.         }
  605.         sprintf(gww,"%5.1f",diff);
  606.         frames=diff;
  607.          if (framemode>1)
  608.   RtgText(RtgScreen,sadr,gww,5,0,180);
  609.  
  610.       }
  611.  
  612.       }
  613.  
  614.       /* Key pollen */
  615.       if(RTGInputRecord.LastKey!=0){
  616.         RTGIe.ie_NextEvent = NULL;
  617.         RTGIe.ie_Class = IECLASS_RAWKEY;
  618.         RTGIe.ie_Code = RTGInputRecord.LastKey;
  619.         RTGIe.ie_Qualifier = 0;
  620.         RTGIe.ie_position.ie_addr = NULL;
  621.         RawKeyConvert(&RTGIe, buffer, 10, NULL);
  622.         RTGInputRecord.LastKey = 0;
  623.         switch(buffer[0]){
  624.           case -101:
  625.             switch(buffer[1]){
  626.               case 65 /*CURSORUP   */: vz+=scale_height/2; break;
  627.               case 66 /*CURSORDOWN */: vz-=scale_height/2; break;
  628.               case 67 /*CURSORRIGHT*/: va  += 5; break;
  629.               case 68 /*CURSORLEFT */: va  -= 5; break;
  630.               case 48: /* F1 */
  631.                 win.x1=0;
  632.                 win.x2=319;
  633.                 t1=t2;
  634.                 anz_frames=0;
  635.                 Clear_Screen(RtgScreen);
  636.               break;
  637.               case 49: /* F2 */
  638.                 win.x1=20;
  639.                 win.x2=299;
  640.                 t1=t2;
  641.                 anz_frames=0;
  642.                 Clear_Screen(RtgScreen);
  643.               break;
  644.               case 50: /* F3 */
  645.                 win.x1=40;
  646.                 win.x2=279;
  647.                 t1=t2;
  648.                 anz_frames=0;
  649.                 Clear_Screen(RtgScreen);
  650.                 break;
  651.               case 51: /* F4 */
  652.                 win.x1=60;
  653.                 win.x2=259;
  654.                 t1=t2;
  655.                 anz_frames=0;
  656.                 Clear_Screen(RtgScreen);
  657.                 break;
  658.               case 52: /* F5 */
  659.                 win.x1=80;
  660.                 win.x2=239;
  661.                 t1=t2;
  662.                 anz_frames=0;
  663.                 Clear_Screen(RtgScreen);
  664.                 break;
  665.               case 53: /* F6 */
  666.                 framemode=0;
  667.                 break;
  668.               case 54: /* F7 */
  669.                 framemode=1;
  670.                 break;
  671.               case 55: /* F8 */
  672.                 framemode=2;
  673.                 break;
  674.               case 56: /* F9 */
  675.                 win.dither_mode=(win.dither_mode==5)?0:win.dither_mode+1;
  676.                 t1=t2;
  677.                 anz_frames=0;
  678.                 Clear_Screen(RtgScreen);
  679.               break;
  680.               case 57: /* F10 */
  681.                 win.dither_mode=(win.dither_mode==0)?5:win.dither_mode-1;
  682.                 t1=t2;
  683.                 anz_frames=0;
  684.                 Clear_Screen(RtgScreen);
  685.               break;
  686.               default:
  687.               break;
  688.             }
  689.           break;
  690.           case 27:
  691.           case ' ': done=TRUE; break;
  692.           case '5': vel  = 0; va = 0; vz = 0; break;
  693.           case 'm':
  694.             view=(view==map_view)?cockpit_view:map_view;
  695.             t1=t2;
  696.             anz_frames=0;
  697.           break;
  698.           case 'n': viewer.angle = 0;    break;
  699.           case 'e': viewer.angle = 900;  break;
  700.           case 's': viewer.angle = 1800; break;
  701.           case 'w': viewer.angle = 2700; break;
  702.           case 'r': viewer.angle = (viewer.angle + 1800) % 3600; break;
  703.           case '+':
  704.           case '=': vel -= scale_area / 8; break;
  705.           case '-': vel += scale_area / 8; break;
  706.           default:
  707.           break;
  708.         }
  709.       }
  710.    }
  711.    printf("Frames: %5.1f\n",frames);
  712. }
  713.  
  714.  
  715. const char *       instructions =
  716.  
  717.    "\n\"Moonbase\" 3D Landscape Demo\n"
  718.    "????????????????????????????\n\n"
  719.    "Use the mouse or arrow keys to steer.  Other keys are:\n\n"
  720.    "  + -  Increase/Decrease forward velocity\n"
  721.    "  m    Toggle satellite view\n"
  722.    "  Esc  Quit\n"
  723.    "\nPress Enter to begin.\n"
  724.    "";
  725.  
  726. const char *       closing_msg =
  727.  
  728.    "Moonbase was written by James McNeill (mcneja@wwc.edu)\n"
  729.    "using Watcom C++ and the PMODE/W DOS extender.\n";
  730.  
  731.  
  732. int CloseAll(int mode)
  733. {
  734.   if(GfxBase!=NULL)CloseLibrary(GfxBase);
  735.   if(IntuitionBase!=NULL)CloseLibrary(IntuitionBase);
  736.   if(RTGMasterBase!=NULL)CloseLibrary((struct Library *)RTGMasterBase);
  737.   if(AslBase!=NULL)CloseLibrary(AslBase);
  738.   return(0);
  739. }
  740.  
  741.  
  742. struct TagItem rtag[] = {
  743.     smr_ChunkySupport,  (1<<9),
  744.     smr_PlanarSupport, -1,
  745.     smr_Buffers,        1,
  746.     smr_TitleText,      (ULONG)"MOON Landscape Demo",
  747.     smr_MinWidth,       320,
  748.     smr_MinHeight,      200,
  749.     smr_MaxWidth,       320,
  750.     smr_MaxHeight,      240,
  751.     TAG_DONE,           NULL
  752. };
  753.  
  754. struct TagItem tacks[] = {
  755.     TAG_DONE,           0
  756. };
  757.  
  758. struct TagItem gtag[] = {
  759.     grd_BytesPerRow,    0,
  760.     grd_Width,          0,
  761.     grd_Height,         0,
  762.     grd_Depth,          0,
  763.     grd_PixelLayout,    0,
  764.     grd_ColorSpace,     0,
  765.     grd_PlaneSize,      0,
  766.     grd_BusSystem,      0,
  767.     TAG_DONE,           0
  768. };
  769.  
  770. int RTGScreen(void)
  771. {
  772.   struct TagItem *tag;
  773.   c2psignal=AllocSignal(-1);
  774.   if(1){
  775.     if(NULL!=(RtgScreen = OpenRtgScreen(sr, tacks))){
  776.       if(NULL!=RTGGOpenInput()) {
  777.         RtgSetTextMode(RtgScreen,0,255,JAM1);
  778.         sadr=GetBufAdr(RtgScreen,0);
  779.         GetRtgScreenData(RtgScreen, gtag);
  780.         tag=FindTagItem(grd_PixelLayout, gtag);
  781.         if (tag->ti_Data == grd_PLANAR) Planar = TRUE;
  782.         else Planar = FALSE;
  783.         printf("Screen is %ld x %ld x %ld\n", gtag[1].ti_Data, gtag[2].ti_Data, gtag[3].ti_Data);
  784.         printf("Screenmode is %s\n",(Planar==TRUE)?"Planar":"Chunky");
  785.         set_palette(RtgScreen);
  786.         RTGGAddIPH();
  787.         interact(RtgScreen);
  788.         RTGGRemIPH();
  789.         RTGGCloseInput();
  790.       }
  791.       CloseRtgScreen(RtgScreen);
  792.     }else{
  793.       PutStr("Konnte RTG-Screen 8 Bit nicht öffnen\n");
  794.     }
  795.   }
  796.   FreeSignal(c2psignal);
  797.   return(TRUE);
  798. }
  799.  
  800.  
  801. int main(void)
  802. {
  803.   if(RTGMasterBase=(struct RTGMasterBase *)OpenLibrary((STRPTR)"rtgmaster.library", 0)){
  804.   if (NULL!=(sr=RtgScreenModeReq(rtag)))
  805. {
  806.  WORLD_generate ();
  807.  
  808.    printf ( instructions );   
  809.     if(IntuitionBase=OpenLibrary("intuition.library",0)){
  810.       if(GfxBase = OpenLibrary("graphics.library",0)){
  811.         if(AslBase=OpenLibrary("asl.library", 38L)){         
  812.           RTGScreen();
  813.         }else PutStr("Konnte \"asl.library\" nicht öffnen\n");
  814.       }else PutStr("Konnte \"graphics.library\" nicht öffnen\n");
  815.     }else PutStr("Konnte \"intuition.library\" nicht öffnen\n");
  816.  
  817.   CloseAll(0);
  818.    
  819.  
  820.   printf ( closing_msg );
  821. }
  822. else PutStr("Konnte keine Screenmodes finden\n");
  823.   }else PutStr("Konnte \"rtgmaster.library\" nicht öffnen\n");
  824.   return 0;
  825. }
  826.